﻿namespace System.Drawing
{
    public static class Brushes
    {
        private static Brush aliceBlue;
        private static Brush antiqueWhite;
        private static Brush aqua;
        private static Brush aquamarine;
        private static Brush azure;
        private static Brush beige;
        private static Brush bisque;
        private static Brush black;
        private static Brush blanchedAlmond;
        private static Brush blue;
        private static Brush blueViolet;
        private static Brush brown;
        private static Brush burlyWood;
        private static Brush cadetBlue;
        private static Brush chartreuse;
        private static Brush chocolate;
        private static Brush coral;
        private static Brush cornflowerBlue;
        private static Brush cornsilk;
        private static Brush crimson;
        private static Brush cyan;
        private static Brush darkBlue;
        private static Brush darkCyan;
        private static Brush darkGoldenrod;
        private static Brush darkGray;
        private static Brush darkGreen;
        private static Brush darkKhaki;
        private static Brush darkMagenta;
        private static Brush darkOliveGreen;
        private static Brush darkOrange;
        private static Brush darkOrchid;
        private static Brush darkRed;
        private static Brush darkSalmon;
        private static Brush darkSeaGreen;
        private static Brush darkSlateBlue;
        private static Brush darkSlateGray;
        private static Brush darkTurquoise;
        private static Brush darkViolet;
        private static Brush deepPink;
        private static Brush deepSkyBlue;
        private static Brush dimGray;
        private static Brush dodgerBlue;
        private static Brush firebrick;
        private static Brush floralWhite;
        private static Brush forestGreen;
        private static Brush fuchsia;
        private static Brush gainsboro;
        private static Brush ghostWhite;
        private static Brush gold;
        private static Brush green;
        private static Brush greenYellow;
        private static Brush goldenrod;
        private static Brush gray;
        private static Brush honeydew;
        private static Brush hotPink;
        private static Brush indianRed;
        private static Brush indigo;
        private static Brush ivory;
        private static Brush khaki;
        private static Brush lavender;
        private static Brush lavenderBlush;
        private static Brush lawnGreen;
        private static Brush lemonChiffon;
        private static Brush lightBlue;
        private static Brush lightCoral;
        private static Brush lightCyan;
        private static Brush lightGoldenrodYellow;
        private static Brush lightGray;
        private static Brush lightGreen;
        private static Brush lightPink;
        private static Brush lightSalmon;
        private static Brush lightSeaGreen;
        private static Brush lightSlateGray;
        private static Brush lightSkyBlue;
        private static Brush lightSteelBlue;
        private static Brush lightYellow;
        private static Brush lime;
        private static Brush limeGreen;
        private static Brush linen;
        private static Brush magenta;
        private static Brush maroon;
        private static Brush mediumAquamarine;
        private static Brush mediumBlue;
        private static Brush mediumOrchid;
        private static Brush mediumPurple;
        private static Brush mediumSeaGreen;
        private static Brush mediumSlateBlue;
        private static Brush mediumSpringGreen;
        private static Brush mediumTurquoise;
        private static Brush mediumVioletRed;
        private static Brush midnightBlue;
        private static Brush mintCream;
        private static Brush mistyRose;
        private static Brush moccasin;
        private static Brush navajoWhite;
        private static Brush navy;
        private static Brush oldLace;
        private static Brush olive;
        private static Brush oliveDrab;
        private static Brush orange;
        private static Brush orangeRed;
        private static Brush orchid;
        private static Brush paleGoldenrod;
        private static Brush paleGreen;
        private static Brush paleTurquoise;
        private static Brush paleVioletRed;
        private static Brush papayaWhip;
        private static Brush peachPuff;
        private static Brush peru;
        private static Brush pink;
        private static Brush plum;
        private static Brush powderBlue;
        private static Brush purple;
        private static Brush red;
        private static Brush rosyBrown;
        private static Brush royalBlue;
        private static Brush saddleBrown;
        private static Brush salmon;
        private static Brush sandyBrown;
        private static Brush seaGreen;
        private static Brush seaShell;
        private static Brush sienna;
        private static Brush silver;
        private static Brush slateBlue;
        private static Brush slateGray;
        private static Brush skyBlue;
        private static Brush snow;
        private static Brush springGreen;
        private static Brush steelBlue;
        private static Brush tan;
        private static Brush teal;
        private static Brush thistle;
        private static Brush tomato;
        private static Brush transparent;
        private static Brush turquoise;
        private static Brush violet;
        private static Brush wheat;
        private static Brush white;
        private static Brush whiteSmoke;
        private static Brush yellow;
        private static Brush yellowGreen;

        public static Brush AliceBlue
        {
            get
            {
                if (aliceBlue == null)
                    aliceBlue = new SolidBrush(Color.AliceBlue);

                return aliceBlue;
            }
        }
        public static Brush AntiqueWhite
        {
            get
            {
                if (antiqueWhite == null)
                    antiqueWhite = new SolidBrush(Color.AntiqueWhite);

                return antiqueWhite;
            }
        }
        public static Brush Aqua
        {
            get
            {
                if (aqua == null)
                    aqua = new SolidBrush(Color.Aqua);

                return aqua;
            }
        }
        public static Brush Aquamarine
        {
            get
            {
                if (aquamarine == null)
                    aquamarine = new SolidBrush(Color.Aquamarine);

                return aquamarine;
            }
        }
        public static Brush Azure
        {
            get
            {
                if (azure == null)
                    azure = new SolidBrush(Color.Azure);

                return azure;
            }
        }
        public static Brush Beige
        {
            get
            {
                if (beige == null)
                    beige = new SolidBrush(Color.Beige);

                return beige;
            }
        }
        public static Brush Bisque
        {
            get
            {
                if (bisque == null)
                    bisque = new SolidBrush(Color.Bisque);

                return bisque;
            }
        }
        public static Brush Black
        {
            get
            {
                if (black == null)
                    black = new SolidBrush(Color.Black);

                return black;
            }
        }
        public static Brush BlanchedAlmond
        {
            get
            {
                if (blanchedAlmond == null)
                    blanchedAlmond = new SolidBrush(Color.BlanchedAlmond);

                return blanchedAlmond;
            }
        }
        public static Brush Blue
        {
            get
            {
                if (blue == null)
                    blue = new SolidBrush(Color.Blue);

                return blue;
            }
        }
        public static Brush BlueViolet
        {
            get
            {
                if (blueViolet == null)
                    blueViolet = new SolidBrush(Color.BlueViolet);

                return blueViolet;
            }
        }
        public static Brush Brown
        {
            get
            {
                if (brown == null)
                    brown = new SolidBrush(Color.Brown);

                return brown;
            }
        }
        public static Brush BurlyWood
        {
            get
            {
                if (burlyWood == null)
                    burlyWood = new SolidBrush(Color.BurlyWood);

                return burlyWood;
            }
        }
        public static Brush CadetBlue
        {
            get
            {
                if (cadetBlue == null)
                    cadetBlue = new SolidBrush(Color.CadetBlue);

                return cadetBlue;
            }
        }
        public static Brush Chartreuse
        {
            get
            {
                if (chartreuse == null)
                    chartreuse = new SolidBrush(Color.Chartreuse);

                return chartreuse;
            }
        }
        public static Brush Chocolate
        {
            get
            {
                if (chocolate == null)
                    chocolate = new SolidBrush(Color.Chocolate);

                return chocolate;
            }
        }
        public static Brush Coral
        {
            get
            {
                if (coral == null)
                    coral = new SolidBrush(Color.Coral);

                return coral;
            }
        }
        public static Brush CornflowerBlue
        {
            get
            {
                if (cornflowerBlue == null)
                    cornflowerBlue = new SolidBrush(Color.CornflowerBlue);

                return cornflowerBlue;
            }
        }
        public static Brush Cornsilk
        {
            get
            {
                if (cornsilk == null)
                    cornsilk = new SolidBrush(Color.Cornsilk);

                return cornsilk;
            }
        }
        public static Brush Crimson
        {
            get
            {
                if (crimson == null)
                    crimson = new SolidBrush(Color.Crimson);

                return crimson;
            }
        }
        public static Brush Cyan
        {
            get
            {
                if (cyan == null)
                    cyan = new SolidBrush(Color.Cyan);

                return cyan;
            }
        }
        public static Brush DarkBlue
        {
            get
            {
                if (darkBlue == null)
                    darkBlue = new SolidBrush(Color.DarkBlue);

                return darkBlue;
            }
        }
        public static Brush DarkCyan
        {
            get
            {
                if (darkCyan == null)
                    darkCyan = new SolidBrush(Color.DarkCyan);

                return darkCyan;
            }
        }
        public static Brush DarkGoldenrod
        {
            get
            {
                if (darkGoldenrod == null)
                    darkGoldenrod = new SolidBrush(Color.DarkGoldenrod);

                return darkGoldenrod;
            }
        }
        public static Brush DarkGray
        {
            get
            {
                if (darkGray == null)
                    darkGray = new SolidBrush(Color.DarkGray);

                return darkGray;
            }
        }
        public static Brush DarkGreen
        {
            get
            {
                if (darkGreen == null)
                    darkGreen = new SolidBrush(Color.DarkGreen);

                return darkGreen;
            }
        }
        public static Brush DarkKhaki
        {
            get
            {
                if (darkKhaki == null)
                    darkKhaki = new SolidBrush(Color.DarkKhaki);

                return darkKhaki;
            }
        }
        public static Brush DarkMagenta
        {
            get
            {
                if (darkMagenta == null)
                    darkMagenta = new SolidBrush(Color.DarkMagenta);

                return darkMagenta;
            }
        }
        public static Brush DarkOliveGreen
        {
            get
            {
                if (darkOliveGreen == null)
                    darkOliveGreen = new SolidBrush(Color.DarkOliveGreen);

                return darkOliveGreen;
            }
        }
        public static Brush DarkOrange
        {
            get
            {
                if (darkOrange == null)
                    darkOrange = new SolidBrush(Color.DarkOrange);

                return darkOrange;
            }
        }
        public static Brush DarkOrchid
        {
            get
            {
                if (darkOrchid == null)
                    darkOrchid = new SolidBrush(Color.DarkOrchid);

                return darkOrchid;
            }
        }
        public static Brush DarkRed
        {
            get
            {
                if (darkRed == null)
                    darkRed = new SolidBrush(Color.DarkRed);

                return darkRed;
            }
        }
        public static Brush DarkSalmon
        {
            get
            {
                if (darkSalmon == null)
                    darkSalmon = new SolidBrush(Color.DarkSalmon);

                return darkSalmon;
            }
        }
        public static Brush DarkSeaGreen
        {
            get
            {
                if (darkSeaGreen == null)
                    darkSeaGreen = new SolidBrush(Color.DarkSeaGreen);

                return darkSeaGreen;
            }
        }
        public static Brush DarkSlateBlue
        {
            get
            {
                if (darkSlateBlue == null)
                    darkSlateBlue = new SolidBrush(Color.DarkSlateBlue);

                return darkSlateBlue;
            }
        }
        public static Brush DarkSlateGray
        {
            get
            {
                if (darkSlateGray == null)
                    darkSlateGray = new SolidBrush(Color.DarkSlateGray);

                return darkSlateGray;
            }
        }
        public static Brush DarkTurquoise
        {
            get
            {
                if (darkTurquoise == null)
                    darkTurquoise = new SolidBrush(Color.DarkTurquoise);

                return darkTurquoise;
            }
        }
        public static Brush DarkViolet
        {
            get
            {
                if (darkViolet == null)
                    darkViolet = new SolidBrush(Color.DarkViolet);

                return darkViolet;
            }
        }
        public static Brush DeepPink
        {
            get
            {
                if (deepPink == null)
                    deepPink = new SolidBrush(Color.DeepPink);

                return deepPink;
            }
        }
        public static Brush DeepSkyBlue
        {
            get
            {
                if (deepSkyBlue == null)
                    deepSkyBlue = new SolidBrush(Color.DeepSkyBlue);

                return deepSkyBlue;
            }
        }
        public static Brush DimGray
        {
            get
            {
                if (dimGray == null)
                    dimGray = new SolidBrush(Color.DimGray);

                return dimGray;
            }
        }
        public static Brush DodgerBlue
        {
            get
            {
                if (dodgerBlue == null)
                    dodgerBlue = new SolidBrush(Color.DodgerBlue);

                return dodgerBlue;
            }
        }
        public static Brush Firebrick
        {
            get
            {
                if (firebrick == null)
                    firebrick = new SolidBrush(Color.Firebrick);

                return firebrick;
            }
        }
        public static Brush FloralWhite
        {
            get
            {
                if (floralWhite == null)
                    floralWhite = new SolidBrush(Color.FloralWhite);

                return floralWhite;
            }
        }
        public static Brush ForestGreen
        {
            get
            {
                if (forestGreen == null)
                    forestGreen = new SolidBrush(Color.ForestGreen);

                return forestGreen;
            }
        }
        public static Brush Fuchsia
        {
            get
            {
                if (fuchsia == null)
                    fuchsia = new SolidBrush(Color.Fuchsia);

                return fuchsia;
            }
        }
        public static Brush Gainsboro
        {
            get
            {
                if (gainsboro == null)
                    gainsboro = new SolidBrush(Color.Gainsboro);

                return gainsboro;
            }
        }
        public static Brush GhostWhite
        {
            get
            {
                if (ghostWhite == null)
                    ghostWhite = new SolidBrush(Color.GhostWhite);

                return ghostWhite;
            }
        }
        public static Brush Gold
        {
            get
            {
                if (gold == null)
                    gold = new SolidBrush(Color.Gold);

                return gold;
            }
        }
        public static Brush Green
        {
            get
            {
                if (green == null)
                    green = new SolidBrush(Color.Green);

                return green;
            }
        }
        public static Brush GreenYellow
        {
            get
            {
                if (greenYellow == null)
                    greenYellow = new SolidBrush(Color.GreenYellow);

                return greenYellow;
            }
        }
        public static Brush Goldenrod
        {
            get
            {
                if (goldenrod == null)
                    goldenrod = new SolidBrush(Color.Goldenrod);

                return goldenrod;
            }
        }
        public static Brush Gray
        {
            get
            {
                if (gray == null)
                    gray = new SolidBrush(Color.Gray);

                return gray;
            }
        }
        public static Brush Honeydew
        {
            get
            {
                if (honeydew == null)
                    honeydew = new SolidBrush(Color.Honeydew);

                return honeydew;
            }
        }
        public static Brush HotPink
        {
            get
            {
                if (hotPink == null)
                    hotPink = new SolidBrush(Color.HotPink);

                return hotPink;
            }
        }
        public static Brush IndianRed
        {
            get
            {
                if (indianRed == null)
                    indianRed = new SolidBrush(Color.IndianRed);

                return indianRed;
            }
        }
        public static Brush Indigo
        {
            get
            {
                if (indigo == null)
                    indigo = new SolidBrush(Color.Indigo);

                return indigo;
            }
        }
        public static Brush Ivory
        {
            get
            {
                if (ivory == null)
                    ivory = new SolidBrush(Color.Ivory);

                return ivory;
            }
        }
        public static Brush Khaki
        {
            get
            {
                if (khaki == null)
                    khaki = new SolidBrush(Color.Khaki);

                return khaki;
            }
        }
        public static Brush Lavender
        {
            get
            {
                if (lavender == null)
                    lavender = new SolidBrush(Color.Lavender);

                return lavender;
            }
        }
        public static Brush LavenderBlush
        {
            get
            {
                if (lavenderBlush == null)
                    lavenderBlush = new SolidBrush(Color.LavenderBlush);

                return lavenderBlush;
            }
        }
        public static Brush LawnGreen
        {
            get
            {
                if (lawnGreen == null)
                    lawnGreen = new SolidBrush(Color.LawnGreen);

                return lawnGreen;
            }
        }
        public static Brush LemonChiffon
        {
            get
            {
                if (lemonChiffon == null)
                    lemonChiffon = new SolidBrush(Color.LemonChiffon);

                return lemonChiffon;
            }
        }
        public static Brush LightBlue
        {
            get
            {
                if (lightBlue == null)
                    lightBlue = new SolidBrush(Color.LightBlue);

                return lightBlue;
            }
        }
        public static Brush LightCoral
        {
            get
            {
                if (lightCoral == null)
                    lightCoral = new SolidBrush(Color.LightCoral);

                return lightCoral;
            }
        }
        public static Brush LightCyan
        {
            get
            {
                if (lightCyan == null)
                    lightCyan = new SolidBrush(Color.LightCyan);

                return lightCyan;
            }
        }
        public static Brush LightGoldenrodYellow
        {
            get
            {
                if (lightGoldenrodYellow == null)
                    lightGoldenrodYellow = new SolidBrush(Color.LightGoldenrodYellow);

                return lightGoldenrodYellow;
            }
        }
        public static Brush LightGray
        {
            get
            {
                if (lightGray == null)
                    lightGray = new SolidBrush(Color.LightGray);

                return lightGray;
            }
        }
        public static Brush LightGreen
        {
            get
            {
                if (lightGreen == null)
                    lightGreen = new SolidBrush(Color.LightGreen);

                return lightGreen;
            }
        }
        public static Brush LightPink
        {
            get
            {
                if (lightPink == null)
                    lightPink = new SolidBrush(Color.LightPink);

                return lightPink;
            }
        }
        public static Brush LightSalmon
        {
            get
            {
                if (lightSalmon == null)
                    lightSalmon = new SolidBrush(Color.LightSalmon);

                return lightSalmon;
            }
        }
        public static Brush LightSeaGreen
        {
            get
            {
                if (lightSeaGreen == null)
                    lightSeaGreen = new SolidBrush(Color.LightSeaGreen);

                return lightSeaGreen;
            }
        }
        public static Brush LightSlateGray
        {
            get
            {
                if (lightSlateGray == null)
                    lightSlateGray = new SolidBrush(Color.SlateGray);

                return lightSlateGray;
            }
        }
        public static Brush LightSkyBlue
        {
            get
            {
                if (lightSkyBlue == null)
                    lightSkyBlue = new SolidBrush(Color.LightSkyBlue);

                return lightSkyBlue;
            }
        }
        public static Brush LightSteelBlue
        {
            get
            {
                if (lightSteelBlue == null)
                    lightSteelBlue = new SolidBrush(Color.SteelBlue);

                return lightSteelBlue;
            }
        }
        public static Brush LightYellow
        {
            get
            {
                if (lightYellow == null)
                    lightYellow = new SolidBrush(Color.LightYellow);

                return lightYellow;
            }
        }
        public static Brush Lime
        {
            get
            {
                if (lime == null)
                    lime = new SolidBrush(Color.Lime);

                return lime;
            }
        }
        public static Brush LimeGreen
        {
            get
            {
                if (limeGreen == null)
                    limeGreen = new SolidBrush(Color.LimeGreen);

                return limeGreen;
            }
        }
        public static Brush Linen
        {
            get
            {
                if (linen == null)
                    linen = new SolidBrush(Color.Linen);

                return linen;
            }
        }
        public static Brush Magenta
        {
            get
            {
                if (magenta == null)
                    magenta = new SolidBrush(Color.Magenta);

                return magenta;
            }
        }
        public static Brush Maroon
        {
            get
            {
                if (maroon == null)
                    maroon = new SolidBrush(Color.Maroon);

                return maroon;
            }
        }
        public static Brush MediumAquamarine
        {
            get
            {
                if (mediumAquamarine == null)
                    mediumAquamarine = new SolidBrush(Color.MediumAquamarine);

                return mediumAquamarine;
            }
        }
        public static Brush MediumBlue
        {
            get
            {
                if (mediumBlue == null)
                    mediumBlue = new SolidBrush(Color.MediumBlue);

                return mediumBlue;
            }
        }
        public static Brush MediumOrchid
        {
            get
            {
                if (mediumOrchid == null)
                    mediumOrchid = new SolidBrush(Color.MediumOrchid);

                return mediumOrchid;
            }
        }
        public static Brush MediumPurple
        {
            get
            {
                if (mediumPurple == null)
                    mediumPurple = new SolidBrush(Color.MediumPurple);

                return mediumPurple;
            }
        }
        public static Brush MediumSeaGreen
        {
            get
            {
                if (mediumSeaGreen == null)
                    mediumSeaGreen = new SolidBrush(Color.MediumSeaGreen);

                return mediumSeaGreen;
            }
        }
        public static Brush MediumSlateBlue
        {
            get
            {
                if (mediumSlateBlue == null)
                    mediumSlateBlue = new SolidBrush(Color.MediumSlateBlue);

                return mediumSlateBlue;
            }
        }
        public static Brush MediumSpringGreen
        {
            get
            {
                if (mediumSpringGreen == null)
                    mediumSpringGreen = new SolidBrush(Color.MediumSpringGreen);

                return mediumSpringGreen;
            }
        }
        public static Brush MediumTurquoise
        {
            get
            {
                if (mediumTurquoise == null)
                    mediumTurquoise = new SolidBrush(Color.MediumTurquoise);

                return mediumTurquoise;
            }
        }
        public static Brush MediumVioletRed
        {
            get
            {
                if (mediumVioletRed == null)
                    mediumVioletRed = new SolidBrush(Color.MediumVioletRed);

                return mediumVioletRed;
            }
        }
        public static Brush MidnightBlue
        {
            get
            {
                if (midnightBlue == null)
                    midnightBlue = new SolidBrush(Color.MidnightBlue);

                return midnightBlue;
            }
        }
        public static Brush MintCream
        {
            get
            {
                if (mintCream == null)
                    mintCream = new SolidBrush(Color.MintCream);

                return mintCream;
            }
        }
        public static Brush MistyRose
        {
            get
            {
                if (mistyRose == null)
                    mistyRose = new SolidBrush(Color.MistyRose);

                return mistyRose;
            }
        }
        public static Brush Moccasin
        {
            get
            {
                if (moccasin == null)
                    moccasin = new SolidBrush(Color.Moccasin);

                return moccasin;
            }
        }
        public static Brush NavajoWhite
        {
            get
            {
                if (navajoWhite == null)
                    navajoWhite = new SolidBrush(Color.NavajoWhite);

                return navajoWhite;
            }
        }
        public static Brush Navy
        {
            get
            {
                if (navy == null)
                    navy = new SolidBrush(Color.Navy);

                return navy;
            }
        }
        public static Brush OldLace
        {
            get
            {
                if (oldLace == null)
                    oldLace = new SolidBrush(Color.OldLace);

                return oldLace;
            }
        }
        public static Brush Olive
        {
            get
            {
                if (olive == null)
                    olive = new SolidBrush(Color.Olive);

                return olive;
            }
        }
        public static Brush OliveDrab
        {
            get
            {
                if (oliveDrab == null)
                    oliveDrab = new SolidBrush(Color.OliveDrab);

                return oliveDrab;
            }
        }
        public static Brush Orange
        {
            get
            {
                if (orange == null)
                    orange = new SolidBrush(Color.Orange);

                return orange;
            }
        }
        public static Brush OrangeRed
        {
            get
            {
                if (orangeRed == null)
                    orangeRed = new SolidBrush(Color.OrangeRed);

                return orangeRed;
            }
        }
        public static Brush Orchid
        {
            get
            {
                if (orchid == null)
                    orchid = new SolidBrush(Color.Orchid);

                return orchid;
            }
        }
        public static Brush PaleGoldenrod
        {
            get
            {
                if (paleGoldenrod == null)
                    paleGoldenrod = new SolidBrush(Color.PaleGoldenrod);

                return paleGoldenrod;
            }
        }
        public static Brush PaleGreen
        {
            get
            {
                if (paleGreen == null)
                    paleGreen = new SolidBrush(Color.PaleGreen);

                return paleGreen;
            }
        }
        public static Brush PaleTurquoise
        {
            get
            {
                if (paleTurquoise == null)
                    paleTurquoise = new SolidBrush(Color.PaleTurquoise);

                return paleTurquoise;
            }
        }
        public static Brush PaleVioletRed
        {
            get
            {
                if (paleVioletRed == null)
                    paleVioletRed = new SolidBrush(Color.PaleVioletRed);

                return paleVioletRed;
            }
        }
        public static Brush PapayaWhip
        {
            get
            {
                if (papayaWhip == null)
                    papayaWhip = new SolidBrush(Color.PapayaWhip);

                return papayaWhip;
            }
        }
        public static Brush PeachPuff
        {
            get
            {
                if (peachPuff == null)
                    peachPuff = new SolidBrush(Color.PeachPuff);

                return peachPuff;
            }
        }
        public static Brush Peru
        {
            get
            {
                if (peru == null)
                    peru = new SolidBrush(Color.Peru);

                return peru;
            }
        }
        public static Brush Pink
        {
            get
            {
                if (pink == null)
                    pink = new SolidBrush(Color.Pink);

                return pink;
            }
        }
        public static Brush Plum
        {
            get
            {
                if (plum == null)
                    plum = new SolidBrush(Color.Plum);

                return plum;
            }
        }
        public static Brush PowderBlue
        {
            get
            {
                if (powderBlue == null)
                    powderBlue = new SolidBrush(Color.PowderBlue);

                return powderBlue;
            }
        }
        public static Brush Purple
        {
            get
            {
                if (purple == null)
                    purple = new SolidBrush(Color.Purple);

                return purple;
            }
        }
        public static Brush Red
        {
            get
            {
                if (red == null)
                    red = new SolidBrush(Color.Red);

                return red;
            }
        }
        public static Brush RosyBrown
        {
            get
            {
                if (rosyBrown == null)
                    rosyBrown = new SolidBrush(Color.RosyBrown);

                return rosyBrown;
            }
        }
        public static Brush RoyalBlue
        {
            get
            {
                if (royalBlue == null)
                    royalBlue = new SolidBrush(Color.RoyalBlue);

                return royalBlue;
            }
        }
        public static Brush SaddleBrown
        {
            get
            {
                if (saddleBrown == null)
                    saddleBrown = new SolidBrush(Color.SaddleBrown);

                return saddleBrown;
            }
        }
        public static Brush Salmon
        {
            get
            {
                if (salmon == null)
                    salmon = new SolidBrush(Color.Salmon);

                return salmon;
            }
        }
        public static Brush SandyBrown
        {
            get
            {
                if (sandyBrown == null)
                    sandyBrown = new SolidBrush(Color.SandyBrown);

                return sandyBrown;
            }
        }
        public static Brush SeaGreen
        {
            get
            {
                if (seaGreen == null)
                    seaGreen = new SolidBrush(Color.SeaGreen);

                return seaGreen;
            }
        }
        public static Brush SeaShell
        {
            get
            {
                if (seaShell == null)
                    seaShell = new SolidBrush(Color.SeaShell);

                return seaShell;
            }
        }
        public static Brush Sienna
        {
            get
            {
                if (sienna == null)
                    sienna = new SolidBrush(Color.Sienna);

                return sienna;
            }
        }
        public static Brush Silver
        {
            get
            {
                if (silver == null)
                    silver = new SolidBrush(Color.Silver);

                return silver;
            }
        }
        public static Brush SlateBlue
        {
            get
            {
                if (slateBlue == null)
                    slateBlue = new SolidBrush(Color.SlateBlue);

                return slateBlue;
            }
        }
        public static Brush SlateGray
        {
            get
            {
                if (slateGray == null)
                    slateGray = new SolidBrush(Color.SlateGray);

                return slateGray;
            }
        }
        public static Brush SkyBlue
        {
            get
            {
                if (skyBlue == null)
                    skyBlue = new SolidBrush(Color.SkyBlue);

                return skyBlue;
            }
        }
        public static Brush Snow
        {
            get
            {
                if (snow == null)
                    snow = new SolidBrush(Color.Snow);

                return snow;
            }
        }
        public static Brush SpringGreen
        {
            get
            {
                if (springGreen == null)
                    springGreen = new SolidBrush(Color.SpringGreen);

                return springGreen;
            }
        }
        public static Brush SteelBlue
        {
            get
            {
                if (steelBlue == null)
                    steelBlue = new SolidBrush(Color.SteelBlue);

                return steelBlue;
            }
        }
        public static Brush Tan
        {
            get
            {
                if (tan == null)
                    tan = new SolidBrush(Color.Tan);

                return tan;
            }
        }
        public static Brush Teal
        {
            get
            {
                if (teal == null)
                    teal = new SolidBrush(Color.Teal);

                return teal;
            }
        }
        public static Brush Thistle
        {
            get
            {
                if (thistle == null)
                    thistle = new SolidBrush(Color.Thistle);

                return thistle;
            }
        }
        public static Brush Tomato
        {
            get
            {
                if (tomato == null)
                    tomato = new SolidBrush(Color.Tomato);

                return tomato;
            }
        }
        public static Brush Transparent
        {
            get
            {
                if (transparent == null)
                    transparent = new SolidBrush(Color.Transparent);

                return transparent;
            }
        }
        public static Brush Turquoise
        {
            get
            {
                if (turquoise == null)
                    turquoise = new SolidBrush(Color.Turquoise);

                return turquoise;
            }
        }
        public static Brush Violet
        {
            get
            {
                if (violet == null)
                    violet = new SolidBrush(Color.Violet);

                return violet;
            }
        }
        public static Brush Wheat
        {
            get
            {
                if (wheat == null)
                    wheat = new SolidBrush(Color.Wheat);

                return wheat;
            }
        }
        public static Brush White
        {
            get
            {
                if (white == null)
                    white = new SolidBrush(Color.White);

                return white;
            }
        }
        public static Brush WhiteSmoke
        {
            get
            {
                if (whiteSmoke == null)
                    whiteSmoke = new SolidBrush(Color.WhiteSmoke);

                return whiteSmoke;
            }
        }
        public static Brush Yellow
        {
            get
            {
                if (yellow == null)
                    yellow = new SolidBrush(Color.Yellow);

                return yellow;
            }
        }
        public static Brush YellowGreen
        {
            get
            {
                if (yellowGreen == null)
                    yellowGreen = new SolidBrush(Color.YellowGreen);

                return yellowGreen;
            }
        }
    }
}